home *** CD-ROM | disk | FTP | other *** search
/ Language/OS - Multiplatform Resource Library / LANGUAGE OS.iso / cocktail / reuse.lha / reuse / m2c / SetsC.c < prev    next >
C/C++ Source or Header  |  1992-08-18  |  11KB  |  556 lines
  1. #include "SYSTEM_.h"
  2.  
  3. #ifndef DEFINITION_Sets
  4. #include "Sets.h"
  5. #endif
  6.  
  7. #ifndef DEFINITION_IO
  8. #include "IO.h"
  9. #endif
  10.  
  11. #ifndef DEFINITION_SetsC
  12. #include "SetsC.h"
  13. #endif
  14.  
  15.  
  16. static void CheckSetSet ARGS((SetsC_tSet *Set1, SetsC_tSet *Set2, CHAR Name[], LONGCARD ));
  17. static void CheckSetElmt ARGS((SetsC_tSet *Set, INTEGER Elmt, CHAR Name[], LONGCARD ));
  18. static void CheckSet ARGS((SetsC_tSet *Set, CHAR Name[], LONGCARD ));
  19. static void CheckNotEmpty ARGS((SetsC_tSet *Set, CHAR Name[], LONGCARD ));
  20. static void PrintSet ARGS((SetsC_tSet Set));
  21.  
  22.  
  23. static void CheckSetSet
  24. # ifdef __STDC__
  25. (SetsC_tSet *Set1, SetsC_tSet *Set2, CHAR Name[], LONGCARD O_1)
  26. # else
  27. (Set1, Set2, Name, O_1)
  28. SetsC_tSet *Set1, *Set2;
  29. CHAR Name[];
  30. LONGCARD O_1;
  31. # endif
  32. {
  33.   OPEN_ARRAY_LOCALS
  34.  
  35.   ALLOC_OPEN_ARRAYS(O_1 * sizeof(CHAR), 1)
  36.   COPY_OPEN_ARRAY(Name, O_1, CHAR)
  37.   CheckSet(Set1, Name, O_1);
  38.   CheckSet(Set2, Name, O_1);
  39.   if (Set1->MaxElmt != Set2->MaxElmt) {
  40.     IO_WriteS((System_tFile)IO_StdError, (STRING)"Sets.", 5L);
  41.     IO_WriteS((System_tFile)IO_StdError, Name, O_1);
  42.     IO_WriteS((System_tFile)IO_StdError, (STRING)": incompatible sets", 19L);
  43.     IO_WriteNl((System_tFile)IO_StdError);
  44.     PrintSet(*Set1);
  45.     PrintSet(*Set2);
  46.   }
  47.   FREE_OPEN_ARRAYS
  48. }
  49.  
  50. static void CheckSetElmt
  51. # ifdef __STDC__
  52. (SetsC_tSet *Set, INTEGER Elmt, CHAR Name[], LONGCARD O_2)
  53. # else
  54. (Set, Elmt, Name, O_2)
  55. SetsC_tSet *Set;
  56. INTEGER Elmt;
  57. CHAR Name[];
  58. LONGCARD O_2;
  59. # endif
  60. {
  61.   OPEN_ARRAY_LOCALS
  62.  
  63.   ALLOC_OPEN_ARRAYS(O_2 * sizeof(CHAR), 1)
  64.   COPY_OPEN_ARRAY(Name, O_2, CHAR)
  65.   CheckSet(Set, Name, O_2);
  66.   if (Elmt < 0) {
  67.     IO_WriteS((System_tFile)IO_StdError, (STRING)"Sets.", 5L);
  68.     IO_WriteS((System_tFile)IO_StdError, Name, O_2);
  69.     IO_WriteS((System_tFile)IO_StdError, (STRING)": negative element: ", 20L);
  70.     IO_WriteI((System_tFile)IO_StdError, Elmt, 0L);
  71.     IO_WriteNl((System_tFile)IO_StdError);
  72.     PrintSet(*Set);
  73.   }
  74.   if (Elmt > (SHORTINT)Set->MaxElmt) {
  75.     IO_WriteS((System_tFile)IO_StdError, (STRING)"Sets.", 5L);
  76.     IO_WriteS((System_tFile)IO_StdError, Name, O_2);
  77.     IO_WriteS((System_tFile)IO_StdError, (STRING)": element out of range: ", 24L);
  78.     IO_WriteI((System_tFile)IO_StdError, Elmt, 0L);
  79.     IO_WriteNl((System_tFile)IO_StdError);
  80.     PrintSet(*Set);
  81.   }
  82.   FREE_OPEN_ARRAYS
  83. }
  84.  
  85. static void CheckSet
  86. # ifdef __STDC__
  87. (SetsC_tSet *Set, CHAR Name[], LONGCARD O_3)
  88. # else
  89. (Set, Name, O_3)
  90. SetsC_tSet *Set;
  91. CHAR Name[];
  92. LONGCARD O_3;
  93. # endif
  94. {
  95.   OPEN_ARRAY_LOCALS
  96.  
  97.   ALLOC_OPEN_ARRAYS(O_3 * sizeof(CHAR), 1)
  98.   COPY_OPEN_ARRAY(Name, O_3, CHAR)
  99.   if (Set->BitsetPtr == NIL) {
  100.     IO_WriteS((System_tFile)IO_StdError, (STRING)"Sets.", 5L);
  101.     IO_WriteS((System_tFile)IO_StdError, Name, O_3);
  102.     IO_WriteS((System_tFile)IO_StdError, (STRING)": set probably not initialized", 30L);
  103.     IO_WriteNl((System_tFile)IO_StdError);
  104.     PrintSet(*Set);
  105.   }
  106.   FREE_OPEN_ARRAYS
  107. }
  108.  
  109. static void CheckNotEmpty
  110. # ifdef __STDC__
  111. (SetsC_tSet *Set, CHAR Name[], LONGCARD O_4)
  112. # else
  113. (Set, Name, O_4)
  114. SetsC_tSet *Set;
  115. CHAR Name[];
  116. LONGCARD O_4;
  117. # endif
  118. {
  119.   OPEN_ARRAY_LOCALS
  120.  
  121.   ALLOC_OPEN_ARRAYS(O_4 * sizeof(CHAR), 1)
  122.   COPY_OPEN_ARRAY(Name, O_4, CHAR)
  123.   CheckSet(Set, Name, O_4);
  124.   if (Sets_IsEmpty(*Set)) {
  125.     IO_WriteS((System_tFile)IO_StdError, (STRING)"Sets.", 5L);
  126.     IO_WriteS((System_tFile)IO_StdError, Name, O_4);
  127.     IO_WriteS((System_tFile)IO_StdError, (STRING)": applied to empty set", 22L);
  128.     IO_WriteNl((System_tFile)IO_StdError);
  129.     PrintSet(*Set);
  130.   }
  131.   FREE_OPEN_ARRAYS
  132. }
  133.  
  134. static void PrintSet
  135. # ifdef __STDC__
  136. (SetsC_tSet Set)
  137. # else
  138. (Set)
  139. SetsC_tSet Set;
  140. # endif
  141. {
  142.   {
  143.     register Sets_tSet *W_1 = &Set;
  144.  
  145.     IO_WriteS((System_tFile)IO_StdError, (STRING)"BitsetPtr = ", 12L);
  146.     IO_WriteN((System_tFile)IO_StdError, (LONGCARD)(INTEGER)W_1->BitsetPtr, 0L, 16L);
  147.     IO_WriteNl((System_tFile)IO_StdError);
  148.     IO_WriteS((System_tFile)IO_StdError, (STRING)"MaxElmt   = ", 12L);
  149.     IO_WriteI((System_tFile)IO_StdError, (LONGINT)W_1->MaxElmt, 0L);
  150.     IO_WriteNl((System_tFile)IO_StdError);
  151.     IO_WriteS((System_tFile)IO_StdError, (STRING)"LastBitset= ", 12L);
  152.     IO_WriteI((System_tFile)IO_StdError, (LONGINT)W_1->LastBitset, 0L);
  153.     IO_WriteNl((System_tFile)IO_StdError);
  154.     IO_WriteS((System_tFile)IO_StdError, (STRING)"Card      = ", 12L);
  155.     IO_WriteI((System_tFile)IO_StdError, (LONGINT)W_1->Card, 0L);
  156.     IO_WriteNl((System_tFile)IO_StdError);
  157.     IO_WriteS((System_tFile)IO_StdError, (STRING)"FirstElmt = ", 12L);
  158.     IO_WriteI((System_tFile)IO_StdError, (LONGINT)W_1->FirstElmt, 0L);
  159.     IO_WriteNl((System_tFile)IO_StdError);
  160.     IO_WriteS((System_tFile)IO_StdError, (STRING)"LastElmt  = ", 12L);
  161.     IO_WriteI((System_tFile)IO_StdError, (LONGINT)W_1->LastElmt, 0L);
  162.     IO_WriteNl((System_tFile)IO_StdError);
  163.   }
  164. }
  165.  
  166. void SetsC_MakeSet
  167. # ifdef __STDC__
  168. (SetsC_tSet *Set, CARDINAL MaxSize)
  169. # else
  170. (Set, MaxSize)
  171. SetsC_tSet *Set;
  172. CARDINAL MaxSize;
  173. # endif
  174. {
  175.   Sets_MakeSet(Set, MaxSize);
  176.   CheckSet(Set, (STRING)"MakeSet", 7L);
  177. }
  178.  
  179. void SetsC_ReleaseSet
  180. # ifdef __STDC__
  181. (SetsC_tSet *Set)
  182. # else
  183. (Set)
  184. SetsC_tSet *Set;
  185. # endif
  186. {
  187.   CheckSet(Set, (STRING)"ReleaseSet", 10L);
  188.   Sets_ReleaseSet(Set);
  189. }
  190.  
  191. void SetsC_Union
  192. # ifdef __STDC__
  193. (SetsC_tSet *Set1, SetsC_tSet Set2)
  194. # else
  195. (Set1, Set2)
  196. SetsC_tSet *Set1;
  197. SetsC_tSet Set2;
  198. # endif
  199. {
  200.   CheckSetSet(Set1, &Set2, (STRING)"Union", 5L);
  201.   Sets_Union(Set1, Set2);
  202. }
  203.  
  204. void SetsC_Difference
  205. # ifdef __STDC__
  206. (SetsC_tSet *Set1, SetsC_tSet Set2)
  207. # else
  208. (Set1, Set2)
  209. SetsC_tSet *Set1;
  210. SetsC_tSet Set2;
  211. # endif
  212. {
  213.   CheckSetSet(Set1, &Set2, (STRING)"Difference", 10L);
  214.   Sets_Difference(Set1, Set2);
  215. }
  216.  
  217. void SetsC_Intersection
  218. # ifdef __STDC__
  219. (SetsC_tSet *Set1, SetsC_tSet Set2)
  220. # else
  221. (Set1, Set2)
  222. SetsC_tSet *Set1;
  223. SetsC_tSet Set2;
  224. # endif
  225. {
  226.   CheckSetSet(Set1, &Set2, (STRING)"Intersection", 12L);
  227.   Sets_Intersection(Set1, Set2);
  228. }
  229.  
  230. void SetsC_SymDiff
  231. # ifdef __STDC__
  232. (SetsC_tSet *Set1, SetsC_tSet Set2)
  233. # else
  234. (Set1, Set2)
  235. SetsC_tSet *Set1;
  236. SetsC_tSet Set2;
  237. # endif
  238. {
  239.   CheckSetSet(Set1, &Set2, (STRING)"SymDiff", 7L);
  240.   Sets_SymDiff(Set1, Set2);
  241. }
  242.  
  243. void SetsC_Complement
  244. # ifdef __STDC__
  245. (SetsC_tSet *Set)
  246. # else
  247. (Set)
  248. SetsC_tSet *Set;
  249. # endif
  250. {
  251.   CheckSet(Set, (STRING)"Complement", 10L);
  252.   Sets_Complement(Set);
  253. }
  254.  
  255. void SetsC_Include
  256. # ifdef __STDC__
  257. (SetsC_tSet *Set, CARDINAL Elmt)
  258. # else
  259. (Set, Elmt)
  260. SetsC_tSet *Set;
  261. CARDINAL Elmt;
  262. # endif
  263. {
  264.   CheckSetElmt(Set, (LONGINT)Elmt, (STRING)"Include", 7L);
  265.   Sets_Include(Set, Elmt);
  266. }
  267.  
  268. void SetsC_Exclude
  269. # ifdef __STDC__
  270. (SetsC_tSet *Set, CARDINAL Elmt)
  271. # else
  272. (Set, Elmt)
  273. SetsC_tSet *Set;
  274. CARDINAL Elmt;
  275. # endif
  276. {
  277.   CheckSetElmt(Set, (LONGINT)Elmt, (STRING)"Exclude", 7L);
  278.   Sets_Exclude(Set, Elmt);
  279. }
  280.  
  281. CARDINAL SetsC_Card
  282. # ifdef __STDC__
  283. (SetsC_tSet *Set)
  284. # else
  285. (Set)
  286. SetsC_tSet *Set;
  287. # endif
  288. {
  289.   CheckSet(Set, (STRING)"Card", 4L);
  290.   return Sets_Card(Set);
  291. }
  292.  
  293. CARDINAL SetsC_Size
  294. # ifdef __STDC__
  295. (SetsC_tSet *Set)
  296. # else
  297. (Set)
  298. SetsC_tSet *Set;
  299. # endif
  300. {
  301.   CheckSet(Set, (STRING)"Size", 4L);
  302.   return Sets_Size(Set);
  303. }
  304.  
  305. CARDINAL SetsC_Minimum
  306. # ifdef __STDC__
  307. (SetsC_tSet *Set)
  308. # else
  309. (Set)
  310. SetsC_tSet *Set;
  311. # endif
  312. {
  313.   CheckNotEmpty(Set, (STRING)"Minimum", 7L);
  314.   return Sets_Minimum(Set);
  315. }
  316.  
  317. CARDINAL SetsC_Maximum
  318. # ifdef __STDC__
  319. (SetsC_tSet *Set)
  320. # else
  321. (Set)
  322. SetsC_tSet *Set;
  323. # endif
  324. {
  325.   CheckNotEmpty(Set, (STRING)"Maximum", 7L);
  326.   return Sets_Maximum(Set);
  327. }
  328.  
  329. CARDINAL SetsC_Select
  330. # ifdef __STDC__
  331. (SetsC_tSet *Set)
  332. # else
  333. (Set)
  334. SetsC_tSet *Set;
  335. # endif
  336. {
  337.   CheckNotEmpty(Set, (STRING)"Select", 6L);
  338.   return Sets_Select(Set);
  339. }
  340.  
  341. CARDINAL SetsC_Extract
  342. # ifdef __STDC__
  343. (SetsC_tSet *Set)
  344. # else
  345. (Set)
  346. SetsC_tSet *Set;
  347. # endif
  348. {
  349.   CheckNotEmpty(Set, (STRING)"Extract", 7L);
  350.   return Sets_Extract(Set);
  351. }
  352.  
  353. BOOLEAN SetsC_IsSubset
  354. # ifdef __STDC__
  355. (SetsC_tSet Set1, SetsC_tSet Set2)
  356. # else
  357. (Set1, Set2)
  358. SetsC_tSet Set1, Set2;
  359. # endif
  360. {
  361.   CheckSetSet(&Set1, &Set2, (STRING)"IsSubset", 8L);
  362.   return Sets_IsSubset(Set1, Set2);
  363. }
  364.  
  365. BOOLEAN SetsC_IsStrictSubset
  366. # ifdef __STDC__
  367. (SetsC_tSet Set1, SetsC_tSet Set2)
  368. # else
  369. (Set1, Set2)
  370. SetsC_tSet Set1, Set2;
  371. # endif
  372. {
  373.   CheckSetSet(&Set1, &Set2, (STRING)"IsStrictSubset", 14L);
  374.   return Sets_IsStrictSubset(Set1, Set2);
  375. }
  376.  
  377. BOOLEAN SetsC_IsEqual
  378. # ifdef __STDC__
  379. (SetsC_tSet *Set1, SetsC_tSet *Set2)
  380. # else
  381. (Set1, Set2)
  382. SetsC_tSet *Set1, *Set2;
  383. # endif
  384. {
  385.   CheckSetSet(Set1, Set2, (STRING)"IsEqual", 7L);
  386.   return Sets_IsEqual(Set1, Set2);
  387. }
  388.  
  389. BOOLEAN SetsC_IsNotEqual
  390. # ifdef __STDC__
  391. (SetsC_tSet Set1, SetsC_tSet Set2)
  392. # else
  393. (Set1, Set2)
  394. SetsC_tSet Set1, Set2;
  395. # endif
  396. {
  397.   CheckSetSet(&Set1, &Set2, (STRING)"IsNotEqual", 10L);
  398.   return Sets_IsNotEqual(Set1, Set2);
  399. }
  400.  
  401. BOOLEAN SetsC_IsElement
  402. # ifdef __STDC__
  403. (CARDINAL Elmt, SetsC_tSet *Set)
  404. # else
  405. (Elmt, Set)
  406. CARDINAL Elmt;
  407. SetsC_tSet *Set;
  408. # endif
  409. {
  410.   CheckSetElmt(Set, (LONGINT)Elmt, (STRING)"IsElement", 9L);
  411.   return Sets_IsElement(Elmt, Set);
  412. }
  413.  
  414. BOOLEAN SetsC_IsEmpty
  415. # ifdef __STDC__
  416. (SetsC_tSet Set)
  417. # else
  418. (Set)
  419. SetsC_tSet Set;
  420. # endif
  421. {
  422.   CheckSet(&Set, (STRING)"IsEmpty", 7L);
  423.   return Sets_IsEmpty(Set);
  424. }
  425.  
  426. BOOLEAN SetsC_Forall
  427. # ifdef __STDC__
  428. (SetsC_tSet Set, SetsC_ProcOfCardToBool Proc)
  429. # else
  430. (Set, Proc)
  431. SetsC_tSet Set;
  432. SetsC_ProcOfCardToBool Proc;
  433. # endif
  434. {
  435.   CheckSet(&Set, (STRING)"Forall", 6L);
  436.   return Sets_Forall(Set, Proc);
  437. }
  438.  
  439. BOOLEAN SetsC_Exists
  440. # ifdef __STDC__
  441. (SetsC_tSet Set, SetsC_ProcOfCardToBool Proc)
  442. # else
  443. (Set, Proc)
  444. SetsC_tSet Set;
  445. SetsC_ProcOfCardToBool Proc;
  446. # endif
  447. {
  448.   CheckSet(&Set, (STRING)"Exists", 6L);
  449.   return Sets_Exists(Set, Proc);
  450. }
  451.  
  452. BOOLEAN SetsC_Exists1
  453. # ifdef __STDC__
  454. (SetsC_tSet Set, SetsC_ProcOfCardToBool Proc)
  455. # else
  456. (Set, Proc)
  457. SetsC_tSet Set;
  458. SetsC_ProcOfCardToBool Proc;
  459. # endif
  460. {
  461.   CheckSet(&Set, (STRING)"Exists1", 7L);
  462.   return Sets_Exists1(Set, Proc);
  463. }
  464.  
  465. void SetsC_Assign
  466. # ifdef __STDC__
  467. (SetsC_tSet *Set1, SetsC_tSet Set2)
  468. # else
  469. (Set1, Set2)
  470. SetsC_tSet *Set1;
  471. SetsC_tSet Set2;
  472. # endif
  473. {
  474.   CheckSetSet(Set1, &Set2, (STRING)"Assign", 6L);
  475.   Sets_Assign(Set1, Set2);
  476. }
  477.  
  478. void SetsC_AssignElmt
  479. # ifdef __STDC__
  480. (SetsC_tSet *Set, CARDINAL Elmt)
  481. # else
  482. (Set, Elmt)
  483. SetsC_tSet *Set;
  484. CARDINAL Elmt;
  485. # endif
  486. {
  487.   CheckSetElmt(Set, (LONGINT)Elmt, (STRING)"AssignElmt", 10L);
  488.   Sets_AssignElmt(Set, Elmt);
  489. }
  490.  
  491. void SetsC_AssignEmpty
  492. # ifdef __STDC__
  493. (SetsC_tSet *Set)
  494. # else
  495. (Set)
  496. SetsC_tSet *Set;
  497. # endif
  498. {
  499.   CheckSet(Set, (STRING)"AssignEmpty", 11L);
  500.   Sets_AssignEmpty(Set);
  501. }
  502.  
  503. void SetsC_ForallDo
  504. # ifdef __STDC__
  505. (SetsC_tSet Set, SetsC_ProcOfCard Proc)
  506. # else
  507. (Set, Proc)
  508. SetsC_tSet Set;
  509. SetsC_ProcOfCard Proc;
  510. # endif
  511. {
  512.   CheckSet(&Set, (STRING)"ForallDo", 8L);
  513.   Sets_ForallDo(Set, Proc);
  514. }
  515.  
  516. void SetsC_ReadSet
  517. # ifdef __STDC__
  518. (IO_tFile f, SetsC_tSet *Set)
  519. # else
  520. (f, Set)
  521. IO_tFile f;
  522. SetsC_tSet *Set;
  523. # endif
  524. {
  525.   CheckSet(Set, (STRING)"ReadSet", 7L);
  526.   Sets_ReadSet(f, Set);
  527. }
  528.  
  529. void SetsC_WriteSet
  530. # ifdef __STDC__
  531. (IO_tFile f, SetsC_tSet Set)
  532. # else
  533. (f, Set)
  534. IO_tFile f;
  535. SetsC_tSet Set;
  536. # endif
  537. {
  538.   CheckSet(&Set, (STRING)"WriteSet", 8L);
  539.   Sets_WriteSet(f, Set);
  540. }
  541.  
  542. void BEGIN_SetsC()
  543. {
  544.   static BOOLEAN has_been_called = FALSE;
  545.  
  546.   if (!has_been_called) {
  547.     has_been_called = TRUE;
  548.  
  549.     BEGIN_IO();
  550.     BEGIN_Sets();
  551.     BEGIN_Sets();
  552.     BEGIN_IO();
  553.  
  554.   }
  555. }
  556.